Developer CD Series 1998 January: Technology Seed/Jan. '98 ATS.toast/QuickTime™ 3.0b11/QTPublicInterfaces/CIncludes/GXTypes.h

C/C++ Source or Header | 1998-01-12 | 51.0 KB | 2,001 lines | [TEXT/MPS ]

/*
     File:        GXTypes.h

     Contains:    QuickDraw GX object and constant definitions

     Version:    Technology:    Quickdraw GX 1.1
                 Release:    QuickTime 3.0 Beta

     Copyright:    © 1994-1997 by Apple Computer, Inc., all rights reserved.

     Bugs?:        Please include the the file and version information (from above) with
                 the problem description.  Developers belonging to one of the Apple
                 developer programs can submit bug reports to:

                     [e-mail]

*/
#ifndef __GXTYPES__
#define __GXTYPES__

#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
#ifndef __FIXMATH__
#include <FixMath.h>
#endif
#ifndef __GXMATH__
#include <GXMath.h>
#endif



#if PRAGMA_ONCE
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif



typedef struct OpaquegxShape*             gxShape;
typedef struct OpaquegxStyle*             gxStyle;
typedef struct OpaquegxInk*             gxInk;
typedef struct OpaquegxTransform*         gxTransform;
typedef struct OpaquegxTag*             gxTag;
typedef struct OpaquegxColorSet*         gxColorSet;
typedef struct OpaquegxColorProfile*     gxColorProfile;
typedef struct OpaquegxGraphicsClient*     gxGraphicsClient;
typedef struct OpaquegxViewGroup*         gxViewGroup;
typedef struct OpaquegxViewPort*         gxViewPort;
typedef struct OpaquegxViewDevice*         gxViewDevice;

typedef long                             gxColorSpace;
/* gxShape enumerations */

enum {
    gxEmptyType                    = 1,
    gxPointType                    = 2,
    gxLineType                    = 3,
    gxCurveType                    = 4,
    gxRectangleType                = 5,
    gxPolygonType                = 6,
    gxPathType                    = 7,
    gxBitmapType                = 8,
    gxTextType                    = 9,
    gxGlyphType                    = 10,
    gxLayoutType                = 11,
    gxFullType                    = 12,
    gxPictureType                = 13
};

typedef long                             gxShapeType;

enum {
    gxNoFill                    = 0,
    gxOpenFrameFill                = 1,
    gxFrameFill                    = gxOpenFrameFill,
    gxClosedFrameFill            = 2,
    gxHollowFill                = gxClosedFrameFill,
    gxEvenOddFill                = 3,
    gxSolidFill                    = gxEvenOddFill,
    gxWindingFill                = 4,
    gxInverseEvenOddFill        = 5,
    gxInverseSolidFill            = gxInverseEvenOddFill,
    gxInverseFill                = gxInverseEvenOddFill,
    gxInverseWindingFill        = 6
};

typedef long                             gxShapeFill;

enum {
    gxNoAttributes                = 0,
    gxDirectShape                = 0x0001,
    gxRemoteShape                = 0x0002,
    gxCachedShape                = 0x0004,
    gxLockedShape                = 0x0008,
    gxGroupShape                = 0x0010,
    gxMapTransformShape            = 0x0020,
    gxUniqueItemsShape            = 0x0040,
    gxIgnorePlatformShape        = 0x0080,
    gxNoMetricsGridShape        = 0x0100,
    gxDiskShape                    = 0x0200,
    gxMemoryShape                = 0x0400
};

typedef long                             gxShapeAttribute;
/* gxShape editing enumerations */

enum {
    gxBreakNeitherEdit            = 0,
    gxBreakLeftEdit                = 0x0001,
    gxBreakRightEdit            = 0x0002,
    gxRemoveDuplicatePointsEdit    = 0x0004
};

/* if the new first (or last) point exactly matches the point before it in */
/* the same contour, then remove it) */
typedef long                             gxEditShapeFlag;

enum {
    gxSelectToEnd                = -1
};

#define gxSetToNil    (void *)(-1)
#define gxAnyNumber     1

enum {
    gxCounterclockwiseDirection    = 0,
    gxClockwiseDirection        = 1
};

typedef long                             gxContourDirection;
/* gxShape structures */
/* The type 'gxPoint' is defined in "GXMath.h" */

struct gxLine {
    gxPoint                         first;
    gxPoint                         last;
};
typedef struct gxLine                    gxLine;

struct gxCurve {
    gxPoint                         first;
    gxPoint                         control;
    gxPoint                         last;
};
typedef struct gxCurve                    gxCurve;

struct gxRectangle {
    Fixed                             left;
    Fixed                             top;
    Fixed                             right;
    Fixed                             bottom;
};
typedef struct gxRectangle                gxRectangle;

struct gxPolygon {
    long                             vectors;
    gxPoint                         vector[1];
};
typedef struct gxPolygon                gxPolygon;

struct gxPolygons {
    long                             contours;
    gxPolygon                         contour[1];
};
typedef struct gxPolygons                gxPolygons;

struct gxPath {
    long                             vectors;
    long                             controlBits[1];
    gxPoint                         vector[1];
};
typedef struct gxPath                    gxPath;

struct gxPaths {
    long                             contours;
    gxPath                             contour[1];
};
typedef struct gxPaths                    gxPaths;

struct gxBitmap {
    char            *image;        /* pointer to pixels */
    long            width;        /* width in pixels */
    long            height;        /* height in pixels */
    long            rowBytes;    /* width in bytes */
    long            pixelSize;        /* physical bits per pixel */
    gxColorSpace      space;
    gxColorSet        set;
    gxColorProfile    profile;
};
typedef struct gxBitmap gxBitmap;

struct gxLongRectangle {
    long                             left;
    long                             top;
    long                             right;
    long                             bottom;
};
typedef struct gxLongRectangle            gxLongRectangle;
/* gxStyle enumerations */

enum {
    gxCenterFrameStyle            = 0,
    gxSourceGridStyle            = 0x0001,
    gxDeviceGridStyle            = 0x0002,
    gxInsideFrameStyle            = 0x0004,
    gxOutsideFrameStyle            = 0x0008,
    gxAutoInsetStyle            = 0x0010
};


typedef long                             gxStyleAttribute;

enum {
    gxBendDash                    = 0x0001,
    gxBreakDash                    = 0x0002,
    gxClipDash                    = 0x0004,
    gxLevelDash                    = 0x0008,
    gxAutoAdvanceDash            = 0x0010
};

typedef long                             gxDashAttribute;

enum {
    gxPortAlignPattern            = 0x0001,
    gxPortMapPattern            = 0x0002
};

typedef long                             gxPatternAttribute;

enum {
    gxSharpJoin                    = 0x0000,
    gxCurveJoin                    = 0x0001,
    gxLevelJoin                    = 0x0002,
    gxSnapJoin                    = 0x0004
};

typedef long                             gxJoinAttribute;

enum {
    gxLevelStartCap                = 0x0001,
    gxLevelEndCap                = 0x0002
};

typedef long                             gxCapAttribute;

enum {
    gxAutoAdvanceText            = 0x0001,
    gxNoContourGridText            = 0x0002,
    gxNoMetricsGridText            = 0x0004,
    gxAnchorPointsText            = 0x0008,
    gxVerticalText                = 0x0010,
    gxNoOpticalScaleText        = 0x0020
};

typedef long                             gxTextAttribute;

enum {
    gxLeftJustify                = 0,
    gxCenterJustify                = fract1 / 2,
    gxRightJustify                = fract1,
    gxFillJustify                = -1
};


enum {
    gxUnderlineAdvanceLayer        = 0x0001,                        /* a gxLine is drawn through the advances */
    gxSkipWhiteSpaceLayer        = 0x0002,                        /* except characters describing white space */
    gxUnderlineIntervalLayer    = 0x0004,                        /* (+ gxStringLayer) a gxLine is drawn through the gaps between advances */
    gxUnderlineContinuationLayer = 0x0008,                        /* (+ gxStringLayer) join this underline with another face */
    gxWhiteLayer                = 0x0010,                        /* the layer draws to white instead of black */
    gxClipLayer                    = 0x0020,                        /* the characters define a clip */
    gxStringLayer                = 0x0040                        /* all characters in run are combined */
};

typedef long                             gxLayerFlag;
/* gxStyle structures */

struct gxFaceLayer {
    gxShapeFill                     outlineFill;                /* outline framed or filled */
    gxLayerFlag                     flags;                        /* various additional effects */
    gxStyle                         outlineStyle;                /* outline */
    gxTransform                     outlineTransform;            /* italic, condense, extend */
    gxPoint                         boldOutset;                    /* bold */
};
typedef struct gxFaceLayer                gxFaceLayer;

struct gxTextFace {
    long                             faceLayers;                    /* layer to implement shadow */
    gxMapping                         advanceMapping;                /* algorithmic change to advance width */
    gxFaceLayer                     faceLayer[1];                /* zero or more face layers describing the face */
};
typedef struct gxTextFace                gxTextFace;

struct gxJoinRecord {
    gxJoinAttribute                 attributes;
    gxShape                         join;
    Fixed                             miter;
};
typedef struct gxJoinRecord                gxJoinRecord;

struct gxDashRecord {
    gxDashAttribute                 attributes;
    gxShape                         dash;                        /* similar to pattern, except rotated to gxLine slope */
    Fixed                             advance;                    /* specifies repeating frequency of dash */
    Fract                             phase;                        /* specifies offset into the gxPath to start dashing */
    Fixed                             scale;                        /* specifies height of dash to be mapped to penWidth */
};
typedef struct gxDashRecord                gxDashRecord;

struct gxPatternRecord {
    gxPatternAttribute                 attributes;
    gxShape                         pattern;
    gxPoint                         u;
    gxPoint                         v;
};
typedef struct gxPatternRecord            gxPatternRecord;

struct gxCapRecord {
    gxCapAttribute                     attributes;
    gxShape                         startCap;
    gxShape                         endCap;
};
typedef struct gxCapRecord                gxCapRecord;

/* gxInk enumerations */

enum {
    gxPortAlignDitherInk        = 0x0001,
    gxForceDitherInk            = 0x0002,
    gxSuppressDitherInk            = 0x0004,
    gxSuppressHalftoneInk        = 0x0008
};


typedef long                             gxInkAttribute;

enum {
    gxNoMode                    = 0,
    gxCopyMode                    = 1,
    gxAddMode                    = 2,
    gxBlendMode                    = 3,
    gxMigrateMode                = 4,
    gxMinimumMode                = 5,
    gxMaximumMode                = 6,
    gxHighlightMode                = 7,
    gxAndMode                    = 8,
    gxOrMode                    = 9,
    gxXorMode                    = 10,
    gxRampAndMode                = 11,
    gxRampOrMode                = 12,
    gxRampXorMode                = 13,
    gxOverMode                    = 14,                            /* Alpha channel modes                */
    gxAtopMode                    = 15,                            /* Note: In England = Beta channel modes        */
    gxExcludeMode                = 16,
    gxFadeMode                    = 17
};

typedef unsigned char                     gxComponentMode;

enum {
    gxRejectSourceTransfer        = 0x0001,                        /* at least one component must be out of range        */
    gxRejectDeviceTransfer        = 0x0002,                        /* at least one component must be out of range        */
    gxSingleComponentTransfer    = 0x0004                        /* duplicate gxTransferComponent[0] for all components in transfer */
};

typedef long                             gxTransferFlag;

enum {
    gxOverResultComponent        = 0x01,                            /* & result gxColor with 0xFFFF before clamping    */
    gxReverseComponent            = 0x02                            /* reverse source and device before moding        */
};

typedef unsigned char                     gxComponentFlag;
/* gxInk structures */

struct gxTransferComponent {
    gxComponentMode                 mode;                        /* how the component is operated upon */
    gxComponentFlag                 flags;                        /* flags for each component    */
    gxColorValue                     sourceMinimum;
    gxColorValue                     sourceMaximum;                /* input filter range */
    gxColorValue                     deviceMinimum;
    gxColorValue                     deviceMaximum;                /* output filter range */
    gxColorValue                     clampMinimum;
    gxColorValue                     clampMaximum;                /* output clamping range */
    gxColorValue                     operand;                    /* ratio for blend, step for migrate, gxColor for highlight    */
};
typedef struct gxTransferComponent        gxTransferComponent;

struct gxTransferMode {
    gxColorSpace        space;            /* the gxColor-space the transfer mode is to operate in    */
    gxColorSet            set;
    gxColorProfile        profile;
    Fixed                sourceMatrix[5][4];
    Fixed                deviceMatrix[5][4];
    Fixed                resultMatrix[5][4];
    gxTransferFlag        flags;
    gxTransferComponent component[4];  /* how each component is operated upon            */
};
typedef struct gxTransferMode gxTransferMode;
/* gxColor space enumerations */

enum {
    gxNoColorPacking            = 0x0000,                        /* 16 bits per channel */
    gxAlphaSpace                = 0x0080,                        /* space includes alpha channel */
    gxWord5ColorPacking            = 0x0500,                        /* 5 bits per channel, right-justified */
    gxLong8ColorPacking            = 0x0800,                        /* 8 bits per channel, right-justified */
    gxLong10ColorPacking        = 0x0A00,                        /* 10 bits per channel, right-justified */
    gxAlphaFirstPacking            = 0x1000                        /* alpha channel is the first field in the packed space */
};


enum {
    gxNoSpace                    = 0,
    gxRGBSpace                    = 1,
    gxCMYKSpace                    = 2,
    gxHSVSpace                    = 3,
    gxHLSSpace                    = 4,
    gxYXYSpace                    = 5,
    gxXYZSpace                    = 6,
    gxLUVSpace                    = 7,
    gxLABSpace                    = 8,
    gxYIQSpace                    = 9,
    gxNTSCSpace                    = gxYIQSpace,
    gxPALSpace                    = gxYIQSpace,
    gxGraySpace                    = 10,
    gxIndexedSpace                = 11,
    gxRGBASpace                    = gxRGBSpace + gxAlphaSpace,
    gxGrayASpace                = gxGraySpace + gxAlphaSpace,
    gxRGB16Space                = gxWord5ColorPacking + gxRGBSpace,
    gxRGB32Space                = gxLong8ColorPacking + gxRGBSpace,
    gxARGB32Space                = gxLong8ColorPacking + gxAlphaFirstPacking + gxRGBASpace,
    gxCMYK32Space                = gxLong8ColorPacking + gxCMYKSpace,
    gxHSV32Space                = gxLong10ColorPacking + gxHSVSpace,
    gxHLS32Space                = gxLong10ColorPacking + gxHLSSpace,
    gxYXY32Space                = gxLong10ColorPacking + gxYXYSpace,
    gxXYZ32Space                = gxLong10ColorPacking + gxXYZSpace,
    gxLUV32Space                = gxLong10ColorPacking + gxLUVSpace,
    gxLAB32Space                = gxLong10ColorPacking + gxLABSpace,
    gxYIQ32Space                = gxLong10ColorPacking + gxYIQSpace,
    gxNTSC32Space                = gxYIQ32Space,
    gxPAL32Space                = gxYIQ32Space
};

/* gxColor space structures */

struct gxRGBColor {
    gxColorValue                     red;
    gxColorValue                     green;
    gxColorValue                     blue;
};
typedef struct gxRGBColor                gxRGBColor;

struct gxRGBAColor {
    gxColorValue                     red;
    gxColorValue                     green;
    gxColorValue                     blue;
    gxColorValue                     alpha;
};
typedef struct gxRGBAColor                gxRGBAColor;

struct gxHSVColor {
    gxColorValue                     hue;
    gxColorValue                     saturation;
    gxColorValue                     value;
};
typedef struct gxHSVColor                gxHSVColor;

struct gxHLSColor {
    gxColorValue                     hue;
    gxColorValue                     lightness;
    gxColorValue                     saturation;
};
typedef struct gxHLSColor                gxHLSColor;

struct gxCMYKColor {
    gxColorValue                     cyan;
    gxColorValue                     magenta;
    gxColorValue                     yellow;
    gxColorValue                     black;
};
typedef struct gxCMYKColor                gxCMYKColor;

struct gxXYZColor {
    gxColorValue                     x;
    gxColorValue                     y;
    gxColorValue                     z;
};
typedef struct gxXYZColor                gxXYZColor;

struct gxYXYColor {
    gxColorValue                     capY;
    gxColorValue                     x;
    gxColorValue                     y;
};
typedef struct gxYXYColor                gxYXYColor;

struct gxLUVColor {
    gxColorValue                     l;
    gxColorValue                     u;
    gxColorValue                     v;
};
typedef struct gxLUVColor                gxLUVColor;

struct gxLABColor {
    gxColorValue                     l;
    gxColorValue                     a;
    gxColorValue                     b;
};
typedef struct gxLABColor                gxLABColor;

struct gxYIQColor {
    gxColorValue                     y;
    gxColorValue                     i;
    gxColorValue                     q;
};
typedef struct gxYIQColor                gxYIQColor;

struct gxGrayAColor {
    gxColorValue                     gray;
    gxColorValue                     alpha;
};
typedef struct gxGrayAColor                gxGrayAColor;

typedef long                             gxColorIndex;
struct gxIndexedColor {
    gxColorIndex      index;
    gxColorSet        set;
};
typedef struct gxIndexedColor gxIndexedColor;

struct gxColor {
    gxColorSpace                     space;
    gxColorProfile                     profile;
    union {
        gxCMYKColor                     cmyk;
        gxRGBColor                         rgb;
        gxRGBAColor                     rgba;
        gxHSVColor                         hsv;
        gxHLSColor                         hls;
        gxXYZColor                         xyz;
        gxYXYColor                         yxy;
        gxLUVColor                         luv;
        gxLABColor                         lab;
        gxYIQColor                         yiq;
        gxColorValue                     gray;
        gxGrayAColor                     graya;
        unsigned short                     pixel16;
        unsigned long                     pixel32;
        gxIndexedColor                     indexed;
        gxColorValue                     component[4];
    }                                 element;
};
typedef struct gxColor                    gxColor;

/* gxColorSet structures */

union gxSetColor {
    gxCMYKColor                     cmyk;
    gxRGBColor                         rgb;
    gxRGBAColor                     rgba;
    gxHSVColor                         hsv;
    gxHLSColor                         hls;
    gxXYZColor                         xyz;
    gxYXYColor                         yxy;
    gxLUVColor                         luv;
    gxLABColor                         lab;
    gxYIQColor                         yiq;
    gxColorValue                     gray;
    gxGrayAColor                     graya;
    unsigned short                     pixel16;
    unsigned long                     pixel32;
    gxColorValue                     component[4];
};
typedef union gxSetColor                gxSetColor;
/* gxTransform enumerations */
/* parts of a gxShape considered in hit testing: */

enum {
    gxNoPart                    = 0,                            /* (in order of evaluation) */
    gxBoundsPart                = 0x0001,
    gxGeometryPart                = 0x0002,
    gxPenPart                    = 0x0004,
    gxCornerPointPart            = 0x0008,
    gxControlPointPart            = 0x0010,
    gxEdgePart                    = 0x0020,
    gxJoinPart                    = 0x0040,
    gxStartCapPart                = 0x0080,
    gxEndCapPart                = 0x0100,
    gxDashPart                    = 0x0200,
    gxPatternPart                = 0x0400,
    gxGlyphBoundsPart            = gxJoinPart,
    gxGlyphFirstPart            = gxStartCapPart,
    gxGlyphLastPart                = gxEndCapPart,
    gxSideBearingPart            = gxDashPart,
    gxAnyPart                    = gxBoundsPart | gxGeometryPart | gxPenPart | gxCornerPointPart | gxControlPointPart | gxEdgePart | gxJoinPart | gxStartCapPart | gxEndCapPart | gxDashPart | gxPatternPart
};


typedef long                             gxShapePart;
/* gxTransform structures */

struct gxHitTestInfo {
    gxShapePart                     what;                        /* which part of gxShape */
    long                             index;                        /* control gxPoint index */
    Fixed                             distance;                    /* how far from gxPoint or outside of area click was */

                                                                /* these fields are only set by GXHitTestPicture */
    gxShape                         which;
    gxShape                         containerPicture;            /* picture which contains gxShape hit */
    long                             containerIndex;                /* the index within that picture  */
    long                             totalIndex;                    /* the total index within the root picture */
};
typedef struct gxHitTestInfo            gxHitTestInfo;
/* gxViewPort enumerations */

enum {
    gxGrayPort                    = 0x0001,
    gxAlwaysGridPort            = 0x0002,
    gxEnableMatchPort            = 0x0004
};


typedef long                             gxPortAttribute;
/* gxViewDevice enumerations */

enum {
    gxDirectDevice                = 0x01,                            /* for the device gxBitmap baseAddr pointer */
    gxRemoteDevice                = 0x02,
    gxInactiveDevice            = 0x04
};

typedef long                             gxDeviceAttribute;

enum {
    gxRoundDot                    = 1,
    gxSpiralDot                    = 2,
    gxSquareDot                    = 3,
    gxLineDot                    = 4,
    gxEllipticDot                = 5,
    gxTriangleDot                = 6,
    gxDispersedDot                = 7,
    gxCustomDot                    = 8
};

typedef long                             gxDotType;
/* gxViewPort structures */

enum {
    gxNoTint                    = 0,
    gxLuminanceTint                = 1,                            /* use the luminance of the gxColor */
    gxAverageTint                = 2,                            /* add all the components and divide by the number of components */
    gxMixtureTint                = 3,                            /* find the closest gxColor on the axis between the foreground and background */
    gxComponent1Tint            = 4,                            /* use the value of the first component of the gxColor */
    gxComponent2Tint            = 5,                            /* ... etc. */
    gxComponent3Tint            = 6,
    gxComponent4Tint            = 7
};

typedef long                             gxTintType;

struct gxHalftone {
    Fixed                             angle;
    Fixed                             frequency;
    gxDotType                         method;
    gxTintType                         tinting;
    gxColor                         dotColor;
    gxColor                         backgroundColor;
    gxColorSpace                     tintSpace;
};
typedef struct gxHalftone                gxHalftone;

struct gxHalftoneMatrix {
    Fixed                             dpiX;                        /* intended resolution */
    Fixed                             dpiY;
    long                             width;                        /* width of matrix (in device pixels) */
    long                             height;                        /* height of matrix (in device pixels) */
    long                             tileShift;                    /* shift amount (in samples) for rectangular tiling */
    unsigned short                     samples[1];                    /* samples from 0..MAX(halftone tintSpace) */
};
typedef struct gxHalftoneMatrix            gxHalftoneMatrix;
/* gxViewGroup enumerations */
#define gxAllViewDevices        ((gxViewGroup) 0)
#define gxScreenViewDevices        ((gxViewGroup) 1)
/* graphics stream constants and structures */

enum {
    gxOpenReadSpool                = 1,
    gxOpenWriteSpool            = 2,
    gxReadSpool                    = 3,
    gxWriteSpool                = 4,
    gxCloseSpool                = 5
};


typedef long                             gxSpoolCommand;
typedef unsigned char                     gxGraphicsOpcode;
typedef struct gxSpoolBlock             gxSpoolBlock;
typedef CALLBACK_API_C( long , gxSpoolProcPtr )(gxSpoolCommand command, gxSpoolBlock *block);
typedef STACK_UPP_TYPE(gxSpoolProcPtr)                             gxSpoolUPP;

struct gxSpoolBlock {
    gxSpoolUPP                         spoolProcedure;                /* these fields are read only */
    void *                            buffer;                        /* source/destination pointer to data */
    long                             bufferSize;                    /* how many bytes for the system to read (flatten) / write (unflatten) */
                                                                /* these fields are written to (but are not read from) */
    long                             count;                        /* how many bytes for the caller to read (unflatten) /write (flatten) */
    long                             operationSize;                /* operation size (including operand byte) */
    long                             operationOffset;            /* the data offset, if any, within the current operation */
    gxGraphicsOpcode                 lastTypeOpcode;                /* type of last created object */
    gxGraphicsOpcode                 currentOperation;            /* operation emitted by flatten, or intrepreted by last unflatten */
    gxGraphicsOpcode                 currentOperand;                /* e.g., gxTransformTypeOpcode, gxInkTagOpcode */
    unsigned char                     compressed;                    /* one of: gxTwoBitCompressionValues */
};

enum { uppgxSpoolProcInfo = 0x000003F1 };                         /* 4_bytes Func(4_bytes, 4_bytes) */
#define NewgxSpoolProc(userRoutine)                             (gxSpoolUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppgxSpoolProcInfo, GetCurrentArchitecture())
#define CallgxSpoolProc(userRoutine, command, block)             CALL_TWO_PARAMETER_UPP((userRoutine), uppgxSpoolProcInfo, (command), (block))


enum {
    gxFontListFlatten            = 0x01,                            /* if set, generate a gxTag containing list of each gxFont referenced */
    gxFontGlyphsFlatten            = 0x02,                            /* if set, generate a gxTag containing the list of glyphs referenced inside the gxFont */
    gxFontVariationsFlatten        = 0x04,                            /* if set, append the gxTag with separate [variation] coordinates */
    gxBitmapAliasFlatten        = 0x08                            /* if set, open bitmap alias files and flatten out their image data */
};


typedef long                             gxFlattenFlag;
/* gxGraphicsClient constants */
#define gxGraphicsSystemClient        (gxGraphicsClient)(-1)

enum {
    gxStaticHeapClient            = 0x0001
};

typedef long                             gxClientAttribute;
/* graphics patching constants */

enum {
    gxOriginalGraphicsFunction    = -1,
    gxOriginalGraphicsIdentifier = FOUR_CHAR_CODE('grfx')
};


struct gxBitmapDataSourceAlias {
    unsigned long                     fileOffset;                    /* file offset (in bytes) of top-left pixel */
    unsigned long                     aliasRecordSize;            /* size of alias record below */
    unsigned char                     aliasRecord[1];                /* the actual alias record data */
};
typedef struct gxBitmapDataSourceAlias    gxBitmapDataSourceAlias;

enum {
    gxBitmapFileAliasTagType    = FOUR_CHAR_CODE('bfil'),
    gxPICTFileAliasTagType        = FOUR_CHAR_CODE('pict'),
    gxBitmapFileAliasImageValue    = 1L
};

typedef struct OpaquegxFont*             gxFont;

enum {
    gxNoPlatform                = 0,
    gxNoScript                    = 0,
    gxNoLanguage                = 0,
    gxNoFontName                = 0,
    gxGlyphPlatform                = -1
};


enum {
    gxUnicodePlatform            = 1,
    gxMacintoshPlatform            = 2,
    gxReservedPlatform            = 3,
    gxMicrosoftPlatform            = 4,
    gxCustomPlatform            = 5
};


typedef long                             gxFontPlatform;

enum {
    gxUnicodeDefaultSemantics    = 1,
    gxUnicodeV1_1Semantics        = 2,
    gxISO10646_1993Semantics    = 3
};


enum {
    gxRomanScript                = 1,
    gxJapaneseScript            = 2,
    gxTraditionalChineseScript    = 3,
    gxChineseScript                = gxTraditionalChineseScript,
    gxKoreanScript                = 4,
    gxArabicScript                = 5,
    gxHebrewScript                = 6,
    gxGreekScript                = 7,
    gxCyrillicScript            = 8,
    gxRussian                    = gxCyrillicScript,
    gxRSymbolScript                = 9,
    gxDevanagariScript            = 10,
    gxGurmukhiScript            = 11,
    gxGujaratiScript            = 12,
    gxOriyaScript                = 13,
    gxBengaliScript                = 14,
    gxTamilScript                = 15,
    gxTeluguScript                = 16,
    gxKannadaScript                = 17,
    gxMalayalamScript            = 18,
    gxSinhaleseScript            = 19,
    gxBurmeseScript                = 20,
    gxKhmerScript                = 21,
    gxThaiScript                = 22,
    gxLaotianScript                = 23,
    gxGeorgianScript            = 24,
    gxArmenianScript            = 25,
    gxSimpleChineseScript        = 26,
    gxTibetanScript                = 27,
    gxMongolianScript            = 28,
    gxGeezScript                = 29,
    gxEthiopicScript            = gxGeezScript,
    gxAmharicScript                = gxGeezScript,
    gxSlavicScript                = 30,
    gxEastEuropeanRomanScript    = gxSlavicScript,
    gxVietnameseScript            = 31,
    gxExtendedArabicScript        = 32,
    gxSindhiScript                = gxExtendedArabicScript,
    gxUninterpretedScript        = 33
};


enum {
    gxMicrosoftSymbolScript        = 1,
    gxMicrosoftStandardScript    = 2
};


enum {
    gxCustom8BitScript            = 1,
    gxCustom816BitScript        = 2,
    gxCustom16BitScript            = 3
};

typedef long                             gxFontScript;

enum {
    gxEnglishLanguage            = 1,
    gxFrenchLanguage            = 2,
    gxGermanLanguage            = 3,
    gxItalianLanguage            = 4,
    gxDutchLanguage                = 5,
    gxSwedishLanguage            = 6,
    gxSpanishLanguage            = 7,
    gxDanishLanguage            = 8,
    gxPortugueseLanguage        = 9,
    gxNorwegianLanguage            = 10,
    gxHebrewLanguage            = 11,
    gxJapaneseLanguage            = 12,
    gxArabicLanguage            = 13,
    gxFinnishLanguage            = 14,
    gxGreekLanguage                = 15,
    gxIcelandicLanguage            = 16,
    gxMalteseLanguage            = 17,
    gxTurkishLanguage            = 18,
    gxCroatianLanguage            = 19,
    gxTradChineseLanguage        = 20,
    gxUrduLanguage                = 21,
    gxHindiLanguage                = 22,
    gxThaiLanguage                = 23,
    gxKoreanLanguage            = 24,
    gxLithuanianLanguage        = 25,
    gxPolishLanguage            = 26,
    gxHungarianLanguage            = 27,
    gxEstonianLanguage            = 28,
    gxLettishLanguage            = 29,
    gxLatvianLanguage            = gxLettishLanguage,
    gxSaamiskLanguage            = 30,
    gxLappishLanguage            = gxSaamiskLanguage,
    gxFaeroeseLanguage            = 31,
    gxFarsiLanguage                = 32,
    gxPersianLanguage            = gxFarsiLanguage,
    gxRussianLanguage            = 33,
    gxSimpChineseLanguage        = 34,
    gxFlemishLanguage            = 35,
    gxIrishLanguage                = 36,
    gxAlbanianLanguage            = 37,
    gxRomanianLanguage            = 38,
    gxCzechLanguage                = 39,
    gxSlovakLanguage            = 40,
    gxSlovenianLanguage            = 41,
    gxYiddishLanguage            = 42,
    gxSerbianLanguage            = 43,
    gxMacedonianLanguage        = 44,
    gxBulgarianLanguage            = 45,
    gxUkrainianLanguage            = 46,
    gxByelorussianLanguage        = 47,
    gxUzbekLanguage                = 48,
    gxKazakhLanguage            = 49,
    gxAzerbaijaniLanguage        = 50,
    gxAzerbaijanArLanguage        = 51,
    gxArmenianLanguage            = 52,
    gxGeorgianLanguage            = 53,
    gxMoldavianLanguage            = 54,
    gxKirghizLanguage            = 55,
    gxTajikiLanguage            = 56,
    gxTurkmenLanguage            = 57,
    gxMongolianLanguage            = 58,
    gxMongolianCyrLanguage        = 59,
    gxPashtoLanguage            = 60,
    gxKurdishLanguage            = 61,
    gxKashmiriLanguage            = 62,
    gxSindhiLanguage            = 63,
    gxTibetanLanguage            = 64,
    gxNepaliLanguage            = 65,
    gxSanskritLanguage            = 66,
    gxMarathiLanguage            = 67,
    gxBengaliLanguage            = 68,
    gxAssameseLanguage            = 69,
    gxGujaratiLanguage            = 70,
    gxPunjabiLanguage            = 71,
    gxOriyaLanguage                = 72,
    gxMalayalamLanguage            = 73,
    gxKannadaLanguage            = 74,
    gxTamilLanguage                = 75,
    gxTeluguLanguage            = 76,
    gxSinhaleseLanguage            = 77,
    gxBurmeseLanguage            = 78,
    gxKhmerLanguage                = 79,
    gxLaoLanguage                = 80,
    gxVietnameseLanguage        = 81,
    gxIndonesianLanguage        = 82,
    gxTagalogLanguage            = 83,
    gxMalayRomanLanguage        = 84,
    gxMalayArabicLanguage        = 85,
    gxAmharicLanguage            = 86,
    gxTigrinyaLanguage            = 87,
    gxGallaLanguage                = 88,
    gxOromoLanguage                = gxGallaLanguage,
    gxSomaliLanguage            = 89,
    gxSwahiliLanguage            = 90,
    gxRuandaLanguage            = 91,
    gxRundiLanguage                = 92,
    gxChewaLanguage                = 93,
    gxMalagasyLanguage            = 94,
    gxEsperantoLanguage            = 95,
    gxWelshLanguage                = 129,
    gxBasqueLanguage            = 130,
    gxCatalanLanguage            = 131,
    gxLatinLanguage                = 132,
    gxQuechuaLanguage            = 133,
    gxGuaraniLanguage            = 134,
    gxAymaraLanguage            = 135,
    gxTatarLanguage                = 136,
    gxUighurLanguage            = 137,
    gxDzongkhaLanguage            = 138,
    gxJavaneseRomLanguage        = 139,
    gxSundaneseRomLanguage        = 140
};

typedef long                             gxFontLanguage;

enum {
    gxCopyrightFontName            = 1,
    gxFamilyFontName            = 2,
    gxStyleFontName                = 3,
    gxUniqueFontName            = 4,
    gxFullFontName                = 5,
    gxVersionFontName            = 6,
    gxPostscriptFontName        = 7,
    gxTrademarkFontName            = 8,
    gxManufacturerFontName        = 9,
    gxLastReservedFontName        = 256
};

typedef long                             gxFontName;
typedef long                             gxFontTableTag;
typedef long                             gxFontVariationTag;
typedef long                             gxFontFormatTag;
typedef long                             gxFontStorageTag;
typedef gxFontVariationTag                 gxFontDescriptorTag;

struct gxFontVariation {
    gxFontVariationTag                 name;
    Fixed                             value;
};
typedef struct gxFontVariation            gxFontVariation;

typedef gxFontVariation                 gxFontDescriptor;

struct gxFontFeatureSetting {
    unsigned short                     setting;
    unsigned short                     nameID;
};
typedef struct gxFontFeatureSetting        gxFontFeatureSetting;

enum {
    gxSystemFontAttribute        = 0x0001,
    gxReadOnlyFontAttribute        = 0x0002
};


typedef long                             gxFontAttribute;

enum {
    gxMutuallyExclusiveFeature    = 0x00008000
};

typedef long                             gxFontFeatureFlag;
typedef long                             gxFontFeature;

enum {
    gxResourceFontStorage        = FOUR_CHAR_CODE('rsrc'),
    gxHandleFontStorage            = FOUR_CHAR_CODE('hndl'),
    gxFileFontStorage            = FOUR_CHAR_CODE('bass'),
    gxNfntFontStorage            = FOUR_CHAR_CODE('nfnt')
};

typedef void *                            gxFontStorageReference;
typedef unsigned short                     gxGlyphcode;
/* single glyph in a font */
/* byte offset within backing store */
typedef long                             gxByteOffset;
/* The actual constants for feature types and selectors have been moved to a library. */
typedef unsigned short                     gxRunFeatureType;
typedef unsigned short                     gxRunFeatureSelector;
/* If tracking is not desired, specify the following value in the track field in the
        gxRunControls record (note that a track of 0 does *not* mean to turn tracking off;
        rather, it means to use normal tracking). */

enum {
    gxNoTracking                = gxNegativeInfinity
};

/* The special "gxNoStake" value is returned by the GXGetLayoutBreakOffset call to
        indicate the absence of a character offset that is stable with respect to
        metamorphosis and contextual kerning. */

enum {
    gxNoStake                    = -1
};

/* A glyph's behavior with respect to other glyphs on its line is defined in part by its
        gxBaselineType. These types allow correct alignment of the baselines of all glyphs on
        the line. */

enum {
    gxRomanBaseline                = 0,
    gxIdeographicCenterBaseline    = 1,
    gxIdeographicLowBaseline    = 2,
    gxHangingBaseline            = 3,
    gxMathBaseline                = 4,
    gxLastBaseline                = 31,
    gxNumberOfBaselineTypes        = gxLastBaseline + 1,
    gxNoOverrideBaseline        = 255
};

typedef unsigned long                     gxBaselineType;
typedef Fixed                             gxBaselineDeltas[32];
/* gxJustificationPriority defines the point during the justification process at which a
    glyph will begin to receive deltas before and after itself. */

enum {
    gxKashidaPriority            = 0,
    gxWhiteSpacePriority        = 1,
    gxInterCharPriority            = 2,
    gxNullJustificationPriority    = 3,
    gxNumberOfJustificationPriorities = 4
};

typedef unsigned char                     gxJustificationPriority;
/* gxJustificationFlags are used to control which fields of a gxWidthDeltaRecord are to
        be overridden and which are not if a gxPriorityJustificationOverride or
        gxGlyphJustificationOverride (qq.v.) is specified. */

enum {
    gxOverridePriority            = 0x8000,                        /* use priority value from override */
    gxOverrideLimits            = 0x4000,                        /* use limits values from override */
    gxOverrideUnlimited            = 0x2000,                        /* use unlimited flag from override */
    gxUnlimitedGapAbsorption    = 0x1000,                        /* glyph can take unlimited gap */
    gxJustificationPriorityMask    = 0x000F,                        /* justification priority */
    gxAllJustificationFlags        = (gxOverridePriority | gxOverrideLimits | gxOverrideUnlimited | gxUnlimitedGapAbsorption | gxJustificationPriorityMask)
};

typedef unsigned short                     gxJustificationFlags;
/* The directional behavior of a glyph can be overridden using a gxDirectionOverride. */

enum {
    gxNoDirectionOverride        = 0,
    gxImposeLeftToRight            = 1,
    gxImposeRightToLeft            = 2,
    gxImposeArabic                = 3
};

typedef unsigned short                     gxDirectionOverride;
/* gxRunControlFlags describe the nonparametric layout options contained in a gxStyle. */

enum {
    gxNoCaretAngle                = 0x40000000,
    gxImposeWidth                = 0x20000000,
    gxNoCrossKerning            = 0x10000000,
    gxNoOpticalAlignment        = 0x08000000,
    gxForceHanging                = 0x04000000,
    gxNoSpecialJustification    = 0x02000000,
    gxDirectionOverrideMask        = 0x00000003,
    gxNoLigatureSplits            = (long)0x80000000
};


enum {
    gxAllRunControlFlags        = (gxNoLigatureSplits | gxNoCaretAngle | gxImposeWidth | gxNoCrossKerning | gxNoOpticalAlignment | gxForceHanging | gxNoSpecialJustification | gxDirectionOverrideMask)
};

typedef unsigned long                     gxRunControlFlags;
/* gxHighlightType is used to distinguish various highlighting methods, both in terms of
        character offset based vs. visual based, and in terms of angled sides vs. non-angled
        sides. */

enum {
    gxHighlightStraight            = 0,                            /* straight-edged simple highlighting */
    gxHighlightAverageAngle        = 1                                /* takes average of two edge angles */
};

typedef unsigned long                     gxHighlightType;
/* gxCaretType is used to control whether the caret that is returned from GXGetLayoutCaret
        is a split caret or a (keyboard-syncronized) single caret. */

enum {
    gxSplitCaretType            = 0,                            /* returns Mac-style split caret (default) */
    gxLeftRightKeyboardCaret    = 1,                            /* single caret in left-right position */
    gxRightLeftKeyboardCaret    = 2                                /* single caret in right-left position */
};

typedef unsigned long                     gxCaretType;
/* gxLayoutOffsetState describes the characteristics of a given gxByteOffset in some
        layout. It is returned by the GXGetOffsetGlyphs call. Note that the
        gxOffsetInsideLigature value is returned in addition to the 8/16 (or invalid)
        indication. */

enum {
    gxOffset8_8                    = 0,
    gxOffset8_16                = 1,
    gxOffset16_8                = 2,
    gxOffset16_16                = 3,
    gxOffsetInvalid                = 4
};


enum {
    gxOffsetInsideLigature        = 0x8000
};

typedef unsigned short                     gxLayoutOffsetState;
/* gxLayoutOptionsFlags are single-bit flags contained in a gxLayoutOptions record. We
    also define here some utility constants that are useful in setting various fields in
    the gxLayoutOptions record. */

enum {
    gxNoLayoutOptions            = 0,
    gxLineIsDisplayOnly            = 0x00000001,
    gxKeepSpacesInMargin        = 0x00000002,
    gxLimitReorderingToTwoLevels = 0x00000004,
    gxLineLeftEdgeNotAtMargin    = 0x00000008,
    gxLineRightEdgeNotAtMargin    = 0x00000010,
    gxAllLayoutOptionsFlags        = gxLineIsDisplayOnly | gxKeepSpacesInMargin | gxLimitReorderingToTwoLevels | gxLineLeftEdgeNotAtMargin | gxLineRightEdgeNotAtMargin,
    gxMaxRunLevel                = 15,
    gxFlushLeft                    = 0,
    gxFlushCenter                = fract1 / 2,
    gxFlushRight                = fract1,
    gxNoJustification            = 0,
    gxFullJustification            = fract1
};

typedef unsigned long                     gxLayoutOptionsFlags;
/* A gxRunFeature describes a feature and a level for that feature. */

struct gxRunFeature {
    gxRunFeatureType                 featureType;
    gxRunFeatureSelector             featureSelector;
};
typedef struct gxRunFeature                gxRunFeature;
/* A gxWidthDeltaRecord contains all of the information needed to describe the behavior of one
        class of glyphs during the justification process. */

struct gxWidthDeltaRecord {
    Fixed                             beforeGrowLimit;            /* ems AW can grow by at most on LT */
    Fixed                             beforeShrinkLimit;            /* ems AW can shrink by at most on LT */
    Fixed                             afterGrowLimit;                /* ems AW can grow by at most on RB */
    Fixed                             afterShrinkLimit;            /* ems AW can shrink by at most on RB */
    gxJustificationFlags             growFlags;                    /* flags controlling grow case */
    gxJustificationFlags             shrinkFlags;                /* flags controlling shrink case */
};
typedef struct gxWidthDeltaRecord        gxWidthDeltaRecord;
/* A gxPriorityJustificationOverride contains an array of WidthDeltaRecords, one for each
        gxJustificationPriority. */

struct gxPriorityJustificationOverride {
    gxWidthDeltaRecord                 deltas[4];                    /* overrides for each of the priorities */
};
typedef struct gxPriorityJustificationOverride gxPriorityJustificationOverride;
/* A gxGlyphJustificationOverride contains a gxWidthDeltaRecord that is to be used for a
        specific glyph in a specific run (this limitation is because glyphcodes vary by font). */

struct gxGlyphJustificationOverride {
    gxGlyphcode                     glyph;
    gxWidthDeltaRecord                 override;
};
typedef struct gxGlyphJustificationOverride gxGlyphJustificationOverride;

/* gxRunControls contains flags, shifts, imposed widths and overrides for a run. */
/* NOTE: a value of "gxNoTracking" (see above) in track disables tracking */

struct gxRunControls {
    gxRunControlFlags                 flags;
    Fixed                             beforeWithStreamShift;
    Fixed                             afterWithStreamShift;
    Fixed                             crossStreamShift;
    Fixed                             imposedWidth;
    Fixed                             track;
    Fract                             hangingInhibitFactor;
    Fract                             kerningInhibitFactor;
    Fixed                             decompositionAdjustmentFactor;
    gxBaselineType                     baselineType;
};
typedef struct gxRunControls            gxRunControls;
/* A gxGlyphSubstitution describes one client-provided substitution that occurs after all
        other automatic glyph changes have happened. */

struct gxGlyphSubstitution {
    gxGlyphcode                     originalGlyph;                /* Whenever you see this glyph... */
    gxGlyphcode                     substituteGlyph;            /* ...change it to this one. */
};
typedef struct gxGlyphSubstitution        gxGlyphSubstitution;
/* gxKerningAdjustmentFactors specify an adjustment to automatic kerning. The adjustment
        is ax + b where x is the automatic kerning value, a is scaleFactor, and b is
        adjustmentPointSizeFactor times the run's point size. */

struct gxKerningAdjustmentFactors {
    Fract                             scaleFactor;
    Fixed                             adjustmentPointSizeFactor;
};
typedef struct gxKerningAdjustmentFactors gxKerningAdjustmentFactors;
/* A gxKerningAdjustment identifies with- and cross-stream kerning adjustments
        for specific glyph pairs. */

struct gxKerningAdjustment {
    gxGlyphcode                     firstGlyph;
    gxGlyphcode                     secondGlyph;
    gxKerningAdjustmentFactors         withStreamFactors;
    gxKerningAdjustmentFactors         crossStreamFactors;
};
typedef struct gxKerningAdjustment        gxKerningAdjustment;
/* A value of gxResetCrossStreamFactor in crossStreamFactors.adjustmentPointSizeFactor
        will reset the cross-stream kerning to the baseline. */

enum {
    gxResetCrossStreamFactor    = gxNegativeInfinity
};

/* gxLayoutHitInfo contains the output from the GXHitTestLayout call. */

struct gxLayoutHitInfo {
    Fixed                             firstPartialDist;
    Fixed                             lastPartialDist;
    gxByteOffset                     hitSideOffset;
    gxByteOffset                     nonHitSideOffset;
    Boolean                         leadingEdge;
    Boolean                         inLoose;
};
typedef struct gxLayoutHitInfo            gxLayoutHitInfo;
/* A gxLineBaselineRecord contains the deltas from 0 to all the different baselines for
        the layout. It can be filled via a call to GetBaselineDeltas (q.v.). */

struct gxLineBaselineRecord {
    gxBaselineDeltas                 deltas;
};
typedef struct gxLineBaselineRecord        gxLineBaselineRecord;
/* The gxLayoutOptions type contains information about the layout characteristics of the
        whole line. */

struct gxLayoutOptions {
    Fixed                             width;
    Fract                             flush;
    Fract                             just;
    gxLayoutOptionsFlags             flags;
    gxLineBaselineRecord *            baselineRec;
};
typedef struct gxLayoutOptions            gxLayoutOptions;

enum {
    gxNewObjectOpcode            = 0x00,                            /* create new object */
    gxSetDataOpcode                = 0x40,                            /* add reference to current object */
    gxSetDefaultOpcode            = 0x80,                            /* replace current default with this object */
    gxReservedOpcode            = 0xC0,                            /* (may be used in future expansion) */
    gxNextOpcode                = 0xFF                            /* used by currentOperand field to say opcode is coming */
};

/* new object types (new object opcode) */

enum {
    gxHeaderTypeOpcode            = 0x00,                            /* byte following new object uses bottom 6 bits for type */
                                                                /* gxShape types use values 1 (gxEmptyType) through 13 (gxPictureType) */
    gxStyleTypeOpcode            = 0x28,
    gxInkTypeOpcode                = 0x29,
    gxTransformTypeOpcode        = 0x2A,
    gxColorProfileTypeOpcode    = 0x2B,
    gxColorSetTypeOpcode        = 0x2C,
    gxTagTypeOpcode                = 0x2D,
    gxBitImageOpcode            = 0x2E,
    gxFontNameTypeOpcode        = 0x2F,
    gxTrailerTypeOpcode            = 0x3F
};

/* fields of objects (set data opcodes) */

enum {
    gxShapeAttributesOpcode        = 0,
    gxShapeTagOpcode            = 1,
    gxShapeFillOpcode            = 2
};


enum {
    gxOmitPathPositionXMask        = 0xC0,
    gxOmitPathPositionYMask        = 0x30,
    gxOmitPathDeltaXMask        = 0x0C,
    gxOmitPathDeltaYMask        = 0x03
};


enum {
    gxOmitPathPositionXShift    = 6,
    gxOmitPathPositionYShift    = 4,
    gxOmitPathDeltaXShift        = 2,
    gxOmitPathDeltaYShift        = 0
};


enum {
    gxOmitBitmapImageMask        = 0xC0,
    gxOmitBitmapWidthMask        = 0x30,
    gxOmitBitmapHeightMask        = 0x0C,
    gxOmitBitmapRowBytesMask    = 0x03
};


enum {
    gxOmitBitmapImageShift        = 6,
    gxOmitBitmapWidthShift        = 4,
    gxOmitBitmapHeightShift        = 2,
    gxOmitBitmapRowBytesShift    = 0
};


enum {
    gxOmitBitmapPixelSizeMask    = 0xC0,
    gxOmitBitmapSpaceMask        = 0x30,
    gxOmitBitmapSetMask            = 0x0C,
    gxOmitBitmapProfileMask        = 0x03
};


enum {
    gxOmitBitmapPixelSizeShift    = 6,
    gxOmitBitmapSpaceShift        = 4,
    gxOmitBitmapSetShift        = 2,
    gxOmitBitmapProfileShift    = 0
};


enum {
    gxOmitBitmapPositionXMask    = 0xC0,
    gxOmitBitmapPositionYMask    = 0x30
};


enum {
    gxOmitBitmapPositionXShift    = 6,
    gxOmitBitmapPositionYShift    = 4
};


enum {
    gxOmitBitImageRowBytesMask    = 0xC0,
    gxOmitBitImageHeightMask    = 0x30,
    gxOmitBitImageDataMask        = 0x08
};


enum {
    gxOmitBitImageRowBytesShift    = 6,
    gxOmitBitImageHeightShift    = 4,
    gxOmitBitImageDataShift        = 3
};


enum {
    gxCopyBitImageBytesOpcode    = 0x00,
    gxRepeatBitImageBytesOpcode    = 0x40,
    gxLookupBitImageBytesOpcode    = 0x80,
    gxRepeatBitImageScanOpcode    = 0xC0
};


enum {
    gxOmitTextCharactersMask    = 0xC0,
    gxOmitTextPositionXMask        = 0x30,
    gxOmitTextPositionYMask        = 0x0C,
    gxOmitTextDataMask            = 0x02
};


enum {
    gxOmitTextCharactersShift    = 6,
    gxOmitTextPositionXShift    = 4,
    gxOmitTextPositionYShift    = 2,
    gxOmitTextDataShift            = 1
};


enum {
    gxOmitGlyphCharactersMask    = 0xC0,
    gxOmitGlyphLengthMask        = 0x30,
    gxOmitGlyphRunNumberMask    = 0x0C,
    gxOmitGlyphOnePositionMask    = 0x02,
    gxOmitGlyphDataMask            = 0x01
};


enum {
    gxOmitGlyphCharactersShift    = 6,
    gxOmitGlyphLengthShift        = 4,
    gxOmitGlyphRunNumberShift    = 2,
    gxOmitGlyphOnePositionShift    = 1,
    gxOmitGlyphDataShift        = 0
};


enum {
    gxOmitGlyphPositionsMask    = 0xC0,
    gxOmitGlyphAdvancesMask        = 0x20,
    gxOmitGlyphTangentsMask        = 0x18,
    gxOmitGlyphRunsMask            = 0x04,
    gxOmitGlyphStylesMask        = 0x03
};


enum {
    gxOmitGlyphPositionsShift    = 6,
    gxOmitGlyphAdvancesShift    = 5,
    gxOmitGlyphTangentsShift    = 3,
    gxOmitGlyphRunsShift        = 2,
    gxOmitGlyphStylesShift        = 0
};


enum {
    gxOmitLayoutLengthMask        = 0xC0,
    gxOmitLayoutPositionXMask    = 0x30,
    gxOmitLayoutPositionYMask    = 0x0C,
    gxOmitLayoutDataMask        = 0x02
};


enum {
    gxOmitLayoutLengthShift        = 6,
    gxOmitLayoutPositionXShift    = 4,
    gxOmitLayoutPositionYShift    = 2,
    gxOmitLayoutDataShift        = 1
};


enum {
    gxOmitLayoutWidthMask        = 0xC0,
    gxOmitLayoutFlushMask        = 0x30,
    gxOmitLayoutJustMask        = 0x0C,
    gxOmitLayoutOptionsMask        = 0x03
};


enum {
    gxOmitLayoutWidthShift        = 6,
    gxOmitLayoutFlushShift        = 4,
    gxOmitLayoutJustShift        = 2,
    gxOmitLayoutOptionsShift    = 0
};


enum {
    gxOmitLayoutStyleRunNumberMask = 0xC0,
    gxOmitLayoutLevelRunNumberMask = 0x30,
    gxOmitLayoutHasBaselineMask    = 0x08,
    gxOmitLayoutStyleRunsMask    = 0x04,
    gxOmitLayoutStylesMask        = 0x03
};


enum {
    gxOmitLayoutStyleRunNumberShift = 6,
    gxOmitLayoutLevelRunNumberShift = 4,
    gxOmitLayoutHasBaselineShift = 3,
    gxOmitLayoutStyleRunsShift    = 2,
    gxOmitLayoutStylesShift        = 0
};


enum {
    gxOmitLayoutLevelRunsMask    = 0x80,
    gxOmitLayoutLevelsMask        = 0x40
};


enum {
    gxOmitLayoutLevelRunsShift    = 7,
    gxOmitLayoutLevelsShift        = 6
};


enum {
    gxInkAttributesOpcode        = 0,
    gxInkTagOpcode                = 1,
    gxInkColorOpcode            = 2,
    gxInkTransferModeOpcode        = 3
};


enum {
    gxOmitColorsSpaceMask        = 0xC0,
    gxOmitColorsProfileMask        = 0x30,
    gxOmitColorsComponentsMask    = 0x0F,
    gxOmitColorsIndexMask        = 0x0C,
    gxOmitColorsIndexSetMask    = 0x03
};


enum {
    gxOmitColorsSpaceShift        = 6,
    gxOmitColorsProfileShift    = 4,
    gxOmitColorsComponentsShift    = 0,
    gxOmitColorsIndexShift        = 2,
    gxOmitColorsIndexSetShift    = 0
};


enum {
    gxOmitTransferSpaceMask        = 0xC0,
    gxOmitTransferSetMask        = 0x30,
    gxOmitTransferProfileMask    = 0x0C
};


enum {
    gxOmitTransferSpaceShift    = 6,
    gxOmitTransferSetShift        = 4,
    gxOmitTransferProfileShift    = 2
};


enum {
    gxOmitTransferSourceMatrixMask = 0xC0,
    gxOmitTransferDeviceMatrixMask = 0x30,
    gxOmitTransferResultMatrixMask = 0x0C,
    gxOmitTransferFlagsMask        = 0x03
};


enum {
    gxOmitTransferSourceMatrixShift = 6,
    gxOmitTransferDeviceMatrixShift = 4,
    gxOmitTransferResultMatrixShift = 2,
    gxOmitTransferFlagsShift    = 0
};


enum {
    gxOmitTransferComponentModeMask = 0x80,
    gxOmitTransferComponentFlagsMask = 0x40,
    gxOmitTransferComponentSourceMinimumMask = 0x30,
    gxOmitTransferComponentSourceMaximumMask = 0x0C,
    gxOmitTransferComponentDeviceMinimumMask = 0x03
};


enum {
    gxOmitTransferComponentModeShift = 7,
    gxOmitTransferComponentFlagsShift = 6,
    gxOmitTransferComponentSourceMinimumShift = 4,
    gxOmitTransferComponentSourceMaximumShift = 2,
    gxOmitTransferComponentDeviceMinimumShift = 0
};


enum {
    gxOmitTransferComponentDeviceMaximumMask = 0xC0,
    gxOmitTransferComponentClampMinimumMask = 0x30,
    gxOmitTransferComponentClampMaximumMask = 0x0C,
    gxOmitTransferComponentOperandMask = 0x03
};


enum {
    gxOmitTransferComponentDeviceMaximumShift = 6,
    gxOmitTransferComponentClampMinimumShift = 4,
    gxOmitTransferComponentClampMaximumShift = 2,
    gxOmitTransferComponentOperandShift = 0
};


enum {
    gxStyleAttributesOpcode        = 0,
    gxStyleTagOpcode            = 1,
    gxStyleCurveErrorOpcode        = 2,
    gxStylePenOpcode            = 3,
    gxStyleJoinOpcode            = 4,
    gxStyleDashOpcode            = 5,
    gxStyleCapsOpcode            = 6,
    gxStylePatternOpcode        = 7,
    gxStyleTextAttributesOpcode    = 8,
    gxStyleTextSizeOpcode        = 9,
    gxStyleFontOpcode            = 10,
    gxStyleTextFaceOpcode        = 11,
    gxStylePlatformOpcode        = 12,
    gxStyleFontVariationsOpcode    = 13,
    gxStyleRunControlsOpcode    = 14,
    gxStyleRunPriorityJustOverrideOpcode = 15,
    gxStyleRunGlyphJustOverridesOpcode = 16,
    gxStyleRunGlyphSubstitutionsOpcode = 17,
    gxStyleRunFeaturesOpcode    = 18,
    gxStyleRunKerningAdjustmentsOpcode = 19,
    gxStyleJustificationOpcode    = 20
};


enum {
    gxOmitDashAttributesMask    = 0xC0,
    gxOmitDashShapeMask            = 0x30,
    gxOmitDashAdvanceMask        = 0x0C,
    gxOmitDashPhaseMask            = 0x03
};


enum {
    gxOmitDashAttributesShift    = 6,
    gxOmitDashShapeShift        = 4,
    gxOmitDashAdvanceShift        = 2,
    gxOmitDashPhaseShift        = 0
};


enum {
    gxOmitDashScaleMask            = 0xC0
};


enum {
    gxOmitDashScaleShift        = 6
};


enum {
    gxOmitPatternAttributesMask    = 0xC0,
    gxOmitPatternShapeMask        = 0x30,
    gxOmitPatternUXMask            = 0x0C,
    gxOmitPatternUYMask            = 0x03
};


enum {
    gxOmitPatternAttributesShift = 6,
    gxOmitPatternShapeShift        = 4,
    gxOmitPatternUXShift        = 2,
    gxOmitPatternUYShift        = 0
};


enum {
    gxOmitPatternVXMask            = 0xC0,
    gxOmitPatternVYMask            = 0x30
};


enum {
    gxOmitPatternVXShift        = 6,
    gxOmitPatternVYShift        = 4
};


enum {
    gxOmitJoinAttributesMask    = 0xC0,
    gxOmitJoinShapeMask            = 0x30,
    gxOmitJoinMiterMask            = 0x0C
};


enum {
    gxOmitJoinAttributesShift    = 6,
    gxOmitJoinShapeShift        = 4,
    gxOmitJoinMiterShift        = 2
};


enum {
    gxOmitCapAttributesMask        = 0xC0,
    gxOmitCapStartShapeMask        = 0x30,
    gxOmitCapEndShapeMask        = 0x0C
};


enum {
    gxOmitCapAttributesShift    = 6,
    gxOmitCapStartShapeShift    = 4,
    gxOmitCapEndShapeShift        = 2
};


enum {
    gxOmitFaceLayersMask        = 0xC0,
    gxOmitFaceMappingMask        = 0x30
};


enum {
    gxOmitFaceLayersShift        = 6,
    gxOmitFaceMappingShift        = 4
};


enum {
    gxOmitFaceLayerFillMask        = 0xC0,
    gxOmitFaceLayerFlagsMask    = 0x30,
    gxOmitFaceLayerStyleMask    = 0x0C,
    gxOmitFaceLayerTransformMask = 0x03
};


enum {
    gxOmitFaceLayerFillShift    = 6,
    gxOmitFaceLayerFlagsShift    = 4,
    gxOmitFaceLayerStyleShift    = 2,
    gxOmitFaceLayerTransformShift = 0
};


enum {
    gxOmitFaceLayerBoldXMask    = 0xC0,
    gxOmitFaceLayerBoldYMask    = 0x30
};


enum {
    gxOmitFaceLayerBoldXShift    = 6,
    gxOmitFaceLayerBoldYShift    = 4
};


enum {
    gxColorSetReservedOpcode    = 0,
    gxColorSetTagOpcode            = 1
};


enum {
    gxColorProfileReservedOpcode = 0,
    gxColorProfileTagOpcode        = 1
};


enum {
    gxTransformReservedOpcode    = 0,
    gxTransformTagOpcode        = 1,
    gxTransformClipOpcode        = 2,
    gxTransformMappingOpcode    = 3,
    gxTransformPartMaskOpcode    = 4,
    gxTransformToleranceOpcode    = 5
};


enum {
    gxTypeOpcode                = 0,
    gxSizeOpcode                = 1
};

/* used by currentOperand when currentOperation is gxNextOpcode */
/*    format of top byte:
xx yyyyyy    xx == 0x00, 0x40, 0x80, 0xC0: defines graphics operation (see gxGraphicsOperationOpcode)
            yyyyyy == size of operation in bytes
            if (yyyyyy == 0), byte size follows. If byte following == 0, word size follows; if == 0, long follows
            word and long, if present, are specified in high-endian order (first byte is largest magnitude)

format of byte following size specifiers, if any:
xx yyyyyy    xx == 0x00, 0x40, 0x80, 0xC0: defines compression level (0 == none, 0xC0 == most)
            exact method of compression is defined by type of data
            yyyyyy == data type selector (0 to 63): see gxGraphicsNewOpcode, __DataOpcode
*/

enum {
    gxOpcodeShift                = 6,
    gxObjectSizeMask            = 0x3F,
    gxCompressionShift            = 6,
    gxObjectTypeMask            = 0x3F,
    gxBitImageOpcodeMask        = 0xC0,
    gxBitImageCountMask            = 0x3F,
    gxBitImageOpcodeShift        = 6
};


enum {
    gxNoCompression                = 0,
    gxWordCompression            = 1,
    gxByteCompression            = 2,
    gxOmitCompression            = 3,
    gxCompressionMask            = 0x03
};

/*    the following structures define how primitives without a public geometry
    are stored (their format mirrors that of the New call to create them)    */

struct gxFlatFontName {
    unsigned char                     name;                        /* gxFontName */
    unsigned char                     platform;                    /* gxFontPlatform */
    unsigned char                     script;                        /* gxFontScript */
    unsigned char                     language;                    /* gxFontLanguage */
    short                             length;                        /* byte length */
};
typedef struct gxFlatFontName            gxFlatFontName;

enum {
    gxFlatFontListItemTag        = FOUR_CHAR_CODE('flst')
};


struct gxFlatFontListItem {
    gxFont                             fontID;                        /*** if we get rid of this, remove #include "font types.h", above */
    unsigned char                     name;                        /* gxFontName */
    unsigned char                     platform;                    /* gxFontPlatform */
    unsigned char                     script;                        /* gxFontScript */
    unsigned char                     language;                    /* gxFontLanguage */
    short                             length;                        /* byte length of the name that follows */
    unsigned short                     glyphCount;                    /* CountFontGlyphs or 0 if gxFontGlyphsFlatten is false */
    unsigned short                     axisCount;                    /* CountFontVariations or 0 if gxFontVariationsFlatten is false */
    unsigned short                     variationCount;                /* number of bitsVariationPairs that follow the (optional) glyphBits */
};
typedef struct gxFlatFontListItem        gxFlatFontListItem;

struct gxFlatFontList {
    long                             count;
    gxFlatFontListItem                 items[1];
};
typedef struct gxFlatFontList            gxFlatFontList;

struct gxFlattenHeader {
    Fixed                             version;
    unsigned char                     flatFlags;
    SInt8                             padding;
};
typedef struct gxFlattenHeader            gxFlattenHeader;

enum {
    gxOmitPictureShapeMask        = 0xC0,
    gxOmitOverrideStyleMask        = 0x30,
    gxOmitOverrideInkMask        = 0x0C,
    gxOmitOverrideTransformMask    = 0x03
};


enum {
    gxOmitPictureShapeShift        = 0x06,
    gxOmitOverrideStyleShift    = 0x04,
    gxOmitOverrideInkShift        = 0x02,
    gxOmitOverrideTransformShift = 0x00
};


enum {
    gxPostScriptTag                = FOUR_CHAR_CODE('post'),
    gxPostControlTag            = FOUR_CHAR_CODE('psct')
};


enum {
    gxNoSave                    = 1,                            /* don't do save-restore around PS data */
    gxPSContinueNext            = 2                                /* next shape is continuation of this shape's PS -- only obeyed if gxNoSave is true */
};


struct gxPostControl {
    long                             flags;                        /* PostScript state flags */
};
typedef struct gxPostControl            gxPostControl;

enum {
    gxDashSynonymTag            = FOUR_CHAR_CODE('sdsh')
};


struct gxDashSynonym {
    long                             size;                        /* number of elements in array */
    Fixed                             dashLength[1];                /* Array of dash lengths */
};
typedef struct gxDashSynonym            gxDashSynonym;

enum {
    gxLineCapSynonymTag            = FOUR_CHAR_CODE('lcap')
};


enum {
    gxButtCap                    = 0,
    gxRoundCap                    = 1,
    gxSquareCap                    = 2,
    gxTriangleCap                = 3
};

/* gxLine cap type */

typedef long                             gxLineCapSynonym;

enum {
    gxCubicSynonymTag            = FOUR_CHAR_CODE('cubx')
};


enum {
    gxIgnoreFlag                = 0x0000,                        /* Ignore this word, get next one */
    gxLineToFlag                = 0x0001,                        /* Draw a gxLine to gxPoint following this flag */
    gxCurveToFlag                = 0x0002,                        /* Draw a gxCurve through the 3 points following this flag */
    gxMoveToFlag                = 0x0003,                        /* Start a new contour at the gxPoint following this flag */
    gxClosePathFlag                = 0x0004                        /* Close the contour */
};

typedef long                             gxCubicSynonym;

enum {
    gxCubicInstructionMask        = 0x000F                        /* low four bits are gxPoint instructions */
};

/* Low four bits are instruction (moveto, lineto, curveto, closepath) */
typedef short                             gxCubicSynonymFlags;

enum {
    gxPatternSynonymTag            = FOUR_CHAR_CODE('ptrn')
};


enum {
    gxHatch                        = 0,
    gxCrossHatch                = 1
};


struct gxPatternSynonym {
    long                             patternType;                /* one of the gxPatterns: gxHatch or gxCrossHatch */
    Fixed                             angle;                        /* angle at which pattern is drawn */
    Fixed                             spacing;                    /* distance between two parallel pattern lines */
    Fixed                             thickness;                    /* thickness of the pattern */
    gxPoint                         anchorPoint;                /* gxPoint with with respect to which pattern position is calculated */
};
typedef struct gxPatternSynonym            gxPatternSynonym;

enum {
    gxURLTag                    = FOUR_CHAR_CODE('urlt')
};


#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif

#ifdef __cplusplus
}
#endif

#endif /* __GXTYPES__ */